// 场景管理器 - 管理多个场景并支持场景切换（只缓存当前场景）
import * as THREE from 'three';

export class SceneManager {
    constructor(container) {
        this.container = container;
        this.renderer = null;
        this.sceneFactories = new Map(); // 存储场景工厂函数
        this.currentScene = null; // 当前激活的场景实例（只保留一个）
        this.currentSceneName = null; // 当前场景名称
        this.clock = new THREE.Clock();
        this.animationId = null;

        this.init();
    }

    init() {
        console.log('🚀 初始化场景管理器...');

        // 创建渲染器
        const width = window.innerWidth;
        const height = window.innerHeight;
        
        this.renderer = new THREE.WebGLRenderer({ antialias: true });
        this.renderer.setSize(width, height);
        this.renderer.shadowMap.enabled = true;
        this.renderer.shadowMap.type = THREE.PCFSoftShadowMap;
        this.container.appendChild(this.renderer.domElement);

        console.log(`📐 画布尺寸: ${width} x ${height}`);

        // 窗口自适应
        window.addEventListener('resize', this.onWindowResize.bind(this));

        // 不再注册默认场景，由项目配置动态注册场景

        // 启动动画循环
        this.animate();

        console.log('✅ 场景管理器初始化完成');
    }

    // 注册新场景（传入工厂函数或场景类）
    registerScene(name, sceneFactory) {
        if (this.sceneFactories.has(name)) {
            console.warn(`⚠️ 场景 "${name}" 已存在，将被覆盖`);
        }
        
        // 如果传入的是类，转换为工厂函数
        const factory = typeof sceneFactory === 'function' && sceneFactory.prototype 
            ? () => new sceneFactory()
            : sceneFactory;
            
        this.sceneFactories.set(name, factory);
        console.log(`📝 场景 "${name}" 已注册`);
    }

    // 切换场景（销毁旧场景，创建新场景）
    switchScene(name) {
        if (!this.sceneFactories.has(name)) {
            console.error(`❌ 场景 "${name}" 不存在`);
            return false;
        }

        // 如果切换到相同场景，不做处理
        if (this.currentSceneName === name && this.currentScene) {
            console.log(`ℹ️ 已经在场景 "${name}" 中`);
            return true;
        }

        // 销毁旧场景
        if (this.currentScene) {
            console.log(`🗑️ 销毁旧场景: ${this.currentSceneName}`);
            this.currentScene.deactivate();
            this.currentScene.dispose();
            this.currentScene = null;
        }

        // 创建新场景实例
        const sceneFactory = this.sceneFactories.get(name);
        const newScene = sceneFactory();
        
        // 初始化新场景
        newScene.init(this.renderer);
        
        // 激活新场景
        newScene.activate();
        this.currentScene = newScene;
        this.currentSceneName = name;

        console.log(`🔄 已切换到场景: ${name}`);
        return true;
    }

    // 获取当前场景
    getCurrentScene() {
        return this.currentScene;
    }

    // 获取所有已注册场景名称
    getSceneNames() {
        return Array.from(this.sceneFactories.keys());
    }
    
    // 获取当前场景名称
    getCurrentSceneName() {
        return this.currentSceneName;
    }

    // 窗口大小改变处理
    onWindowResize() {
        const width = window.innerWidth;
        const height = window.innerHeight;

        if (this.currentScene && this.currentScene.getCamera()) {
            const camera = this.currentScene.getCamera();
            camera.aspect = width / height;
            camera.updateProjectionMatrix();
        }

        this.renderer.setSize(width, height);
    }

    // 动画循环
    animate() {
        this.animationId = requestAnimationFrame(this.animate.bind(this));

        const deltaTime = this.clock.getDelta();

        // 更新当前场景
        if (this.currentScene && this.currentScene.isActive) {
            this.currentScene.update(deltaTime);
            
            this.renderer.render(
                this.currentScene.getScene(),
                this.currentScene.getCamera()
            );
        }
    }

    // 停止动画
    stop() {
        if (this.animationId) {
            cancelAnimationFrame(this.animationId);
            this.animationId = null;
        }
    }

    // 清理所有资源
    dispose() {
        this.stop();
        
        // 清理当前场景
        if (this.currentScene) {
            this.currentScene.dispose();
            this.currentScene = null;
        }
        
        // 清空场景工厂
        this.sceneFactories.clear();
        this.currentSceneName = null;
        
        // 清理渲染器
        if (this.renderer) {
            this.renderer.dispose();
            if (this.renderer.domElement.parentNode) {
                this.renderer.domElement.parentNode.removeChild(this.renderer.domElement);
            }
        }

        console.log('🗑️ 场景管理器已清理');
    }
}

// 导出便捷函数，保持向后兼容
export function setupScene(container) {
    const manager = new SceneManager(container);
    // 将管理器挂载到全局，方便调试和场景切换
    window.sceneManager = manager;
    return manager;
}